package com.thread.syn3;

/**
 * 单例设计模式：确保一个雷只有一个对象
 *
 * @author jiangbang
 * @date 2016/7/21
 */
public class SynDemo02 {
    public static void main(String[] args) {
        JvmThread thread1 = new JvmThread(100l);
        JvmThread thread2 = new JvmThread(500l);
        thread1.start();
        thread2.start();
    }
}

class JvmThread extends Thread{
    private long time;
    public JvmThread(){

    }
    public JvmThread(Long time){

    }
    public void run(){
        System.out.println(Thread.currentThread().getName()+"创建："+JvmDemo.getInstance(time));
        System.out.println(Thread.currentThread().getName()+"创建："+JvmDemo.getInstance01(time));
    }
}

class JvmDemo{
    //声明一个私有的静态变量
    private static JvmDemo instance = null ;
    //构造器私有化，避免外部直接创建对象
    private JvmDemo(){
    }
    //创建一个对外的公共的静态方法，访问该变量，如果变量没有对象，创建该对象
    public static JvmDemo getInstance(long time){
        if(null == instance){
            try {
                Thread.sleep(time);  //放大错误
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new JvmDemo();
        }
        return instance;
    }

    //线程安全
    public static synchronized JvmDemo getInstance01(long time){
        if(null == instance){
            try {
                Thread.sleep(time);  //放大错误
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            instance = new JvmDemo();
        }
        return instance;
    }
}








/**
 * 单例设计模式
 * 确保一个类只有一个对象
 * 懒汉式
 * 1.构造器私有化，避免外部直接创建对象
 * 2。声明一个私有的静态变量
 * 3.创建一个对外的公共的静态方法，访问该变量，如果变量没有对象，创建该对象
 */
class Jvm{
    //声明一个私有的静态变量
    private static Jvm instance = null ;
    //构造器私有化，避免外部直接创建对象
    private Jvm(){
    }
    //创建一个对外的公共的静态方法，访问该变量，如果变量没有对象，创建该对象
    public static Jvm getInstance(){
        if(null == instance){
            synchronized (Jvm.class){//线程安全
                if(null == instance){ //确保安全
                    instance = new Jvm();
                }
            }
        }
        return instance;
    }
}



/**
 * 单例设计模式
 * 确保一个类只有一个对象
 *
 * 饿汉式
 * 1.构造器私有化，避免外部直接创建对象
 * 2。声明一个私有的静态变量 同时创建该对象
 * 3.创建一个对外的公共的静态方法，访问该变量
 */
class Jvm2{
    //声明一个私有的静态变量 同时创建该对象
    private static Jvm2 instance = new Jvm2() ;
    //构造器私有化，避免外部直接创建对象
    private Jvm2(){
    }
    //创建一个对外的公共的静态方法，访问该变量
    public static Jvm2 getInstance(){
        return instance;
    }
}


/**
 * 类来使用的时候在加载，延缓加载时间
 */
class Jvm3{
    private static class Jvmholder{
        //声明一个私有的静态变量 同时创建该对象
        private static Jvm3 instance = new Jvm3() ;
    }

    //构造器私有化，避免外部直接创建对象
    private Jvm3(){
    }
    //创建一个对外的公共的静态方法，访问该变量
    public static Jvm3 getInstance(){
        return Jvmholder.instance;
    }
}